home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / game / 2play / LordOfHosts.lha / LordOfHosts / lohsrc.lzh / main.c < prev    next >
C/C++ Source or Header  |  1991-05-10  |  15KB  |  406 lines
  1. /* LORD OF HOSTS - main.c --- Hauptprogramm */
  2.  
  3. #include "Lord.h"
  4.  
  5. int status,help[2];
  6. BOOL joymouse_allowed;
  7. struct IntuiMessage *msg;
  8.  
  9. extern BOOL joymouse_on;
  10. extern struct Screen     *MyScreen;
  11. extern struct Window     *MyWindow;
  12. extern struct Move Moves[MAXUNDO];
  13. extern struct Menu game_m;
  14. extern struct Piece      ThePieces[16];
  15. extern UBYTE whatsonboard[8][8];
  16. extern int type_of_board,last_error,undopos;
  17. extern char players[2][16];
  18. extern UBYTE fval[16][8][8], kval[16][8][8];
  19.  
  20. void wait_events(void)
  21. {
  22.    while (TRUE)
  23.    {
  24.       Wait(1 << MyWindow->UserPort->mp_SigBit);
  25.       while (msg = (struct IntuiMessage *)GetMsg(MyWindow->UserPort))
  26.       {
  27.          switch (msg->Class)
  28.          {
  29.             case MENUPICK:
  30.                handle_menuevents();
  31.                break;
  32.             case MOUSEBUTTONS:
  33.                if (msg->Code == SELECTDOWN) handle_mouseevents();
  34.                break;
  35.             default:
  36.                break;
  37.          }
  38.          ReplyMsg((struct Message *)msg);
  39.       }
  40.    }
  41. }
  42.  
  43. void handle_menuevents(void)
  44. {
  45.    USHORT MenuNumber,Menu,Item,SubItem;
  46.    char msgstring[100];
  47.    struct MenuItem *MyItem;
  48.    int redohelp;
  49.    MenuNumber = msg->Code;
  50.    if (status & (WAITING_FOR_DEST|WAITING_FOR_CONF))
  51.    {
  52.       SimpleRequest("Please finish this move first!");
  53.       return;
  54.    }
  55.    while (MenuNumber != MENUNULL)
  56.    {
  57.       MyItem = ItemAddress(&game_m,MenuNumber);
  58.       Menu = MENUNUM(MenuNumber);
  59.       Item = ITEMNUM(MenuNumber);
  60.       SubItem = SUBNUM(MenuNumber);
  61.       switch (Menu)
  62.       {
  63.          case 0:  /* Menü GAME */
  64.             switch (Item)
  65.             {
  66.                case 0:  /* BEGIN GAME */
  67.                   if (status & IN_GAME)
  68.                      if (!TwoGadRequest("Abort this game ?"))
  69.                         break;
  70.                   if (!(status & BOARD_UNTOUCHED))
  71.                      switch(type_of_board)
  72.                      {
  73.                         case STD_NORM:
  74.                            drawboard();
  75.                            setup_stdboard(FALSE);
  76.                            break;
  77.                         case STD_ROTD:
  78.                            drawboard();
  79.                            setup_stdboard(TRUE);
  80.                            break;
  81.                         case RND_BAL:
  82.                            drawboard();
  83.                            setup_rndboard(TRUE);
  84.                            break;
  85.                         case RND_UNB:
  86.                            drawboard();
  87.                            setup_rndboard(FALSE);
  88.                            break;
  89.                         default:
  90.                            SimpleRequest("Unknown type of board!");
  91.                            break;
  92.                      }
  93.                   status &= (~IN_GAME);
  94.                   NextPlayer(RED);
  95.                   status |= IN_GAME;
  96.                   status &= (~BOARD_UNTOUCHED);
  97.                   EnterNames();
  98.                   if (rand() % 2)
  99.                   {
  100.                      strcpy(msgstring,players[0]);
  101.                      strcat(msgstring," begins the game!");
  102.                      SimpleRequest(msgstring);
  103.                      status |= PLAYER1_TO_MOVE;
  104.                      NextPlayer(RED);
  105.                   } else {
  106.                      strcpy(msgstring,players[1]);
  107.                      strcat(msgstring," begins the game!");
  108.                      if (joymouse_allowed)
  109.                         strcat(msgstring,"\n(Use a joystick)");
  110.                      SimpleRequest(msgstring);
  111.                      status &= (~PLAYER1_TO_MOVE);
  112.                      NextPlayer(WHITE);
  113.                   }
  114.                   last_error=0; status |= WAITING_FOR_PICK;
  115.                   break;
  116.                case 1:  /* LOAD GAME */
  117.                   if (status & IN_GAME)
  118.                      if (!TwoGadRequest("Abort this game ?"))
  119.                         break;
  120.                   LoadGame();
  121.                   break;
  122.                case 2: /* SAVE GAME */
  123.                   SaveGame();
  124.                   break;
  125.                case 3: /* RULES */
  126.                   Rules();
  127.                   break;
  128.                case 4: /* ABOUT */
  129.                   About();
  130.                   break;
  131.                case 5: /* QUIT */
  132.                   if (status & IN_GAME)
  133.                      if (!TwoGadRequest("Abort this game ?"))
  134.                         break;
  135.                   ReplyMsg((struct Message *)msg);
  136.                   if (joymouse_on) swapjoymouse(FALSE);
  137.                   close_all();
  138.                   break;         /* eigentlich unnötig */
  139.                default:
  140.                   SimpleRequest("Unknown Item number (Menu 0) !");
  141.                   break;
  142.             }
  143.             break;
  144.          case 1:     /* Menü BOARD */
  145.             if (MyItem->Flags & CHECKED)  /* nur, wenn Wahl endgültig */
  146.             {
  147.                if (status & IN_GAME)
  148.                {
  149.                   SimpleRequest("You can't change the board during\n"
  150.                                 "the game. However, your selection\n"
  151.                                 "will  be  taken  into account the\n"
  152.                                 "next time you select BEGIN GAME.");
  153.                   type_of_board = Item;      /* wird beim nächsten BEGIN */
  154.                   break;                     /* gelesen */
  155.                }
  156.                switch (Item)
  157.                {
  158.                   case 0: /* STANDARD */
  159.                      drawboard();
  160.                      setup_stdboard(FALSE);
  161.                      break;
  162.                   case 1: /* STD rotated */
  163.                      drawboard();
  164.                      setup_stdboard(TRUE);
  165.                      break;
  166.                   case 2: /* Random balanced */
  167.                      drawboard();
  168.                      setup_rndboard(TRUE);
  169.                      break;
  170.                   case 3: /* Rnd unbalanced */
  171.                      drawboard();
  172.                      setup_rndboard(FALSE);
  173.                      break;
  174.                   default:
  175.                      SimpleRequest("Unknown Item number (Menu 1) !");
  176.                      break;
  177.                }
  178.             }
  179.             break;
  180.          case 2: /* Menü SPECIAL */
  181.             switch (Item)
  182.             {
  183.                case 0: /* UNDO */
  184.                   if (!undo()) SimpleRequest("Nothing to undo!");
  185.                   else
  186.                   {
  187.                      status = Moves[undopos].status;
  188.                      if (status & PLAYER1_TO_MOVE)
  189.                         NextPlayer(RED);
  190.                      else NextPlayer(WHITE);
  191.                   }
  192.                   break;
  193.                case 1: /* REDO */
  194.                   if (!redo())
  195.                   {
  196.                      SimpleRequest("Nothing to redo!");
  197.                      if (Moves[undopos].GameOver)
  198.                      {
  199.                         status = IDLE;
  200.                         NextPlayer(RED);
  201.                      } else {
  202.                         status = WAITING_FOR_PICK|IN_GAME;
  203.                         redohelp = undopos-1;
  204.                         if (redohelp<0) redohelp+=MAXUNDO;
  205.                         if (!(Moves[redohelp].status & PLAYER1_TO_MOVE))
  206.                         {
  207.                            status |= PLAYER1_TO_MOVE;
  208.                            NextPlayer(RED);
  209.                         } else NextPlayer(WHITE);
  210.                      }
  211.                   }
  212.                   else
  213.                   {
  214.                      if (Moves[undopos].GameOver)
  215.                      {
  216.                         status = IDLE;
  217.                         NextPlayer(RED);
  218.                      } else {
  219.                         status = WAITING_FOR_PICK|IN_GAME;
  220.                         redohelp = undopos-1;
  221.                         if (redohelp<0) redohelp+=MAXUNDO;
  222.                         if (!(Moves[redohelp].status & PLAYER1_TO_MOVE))
  223.                         {
  224.                            status |= PLAYER1_TO_MOVE;
  225.                            NextPlayer(RED);
  226.                         }
  227.                         else NextPlayer(WHITE);
  228.                      }
  229.                   }
  230.                   break;
  231.                case 2: /* Player 1 Help Mode */
  232.                   help[0] = SubItem;
  233.                   break;
  234.                case 3: /* Player 2 Help Mode */
  235.                   help[1] = SubItem;
  236.                   break;
  237.                case 4: /* JoyMouse */
  238.                   if (SubItem)
  239.                   {
  240.                      if (joymouse_on) swapjoymouse(FALSE);
  241.                      joymouse_allowed = FALSE;
  242.                   } else {
  243.                      joymouse_allowed = TRUE;
  244.                      if (!(status & PLAYER1_TO_MOVE) && !joymouse_on &&
  245.                            (status & IN_GAME))
  246.                         swapjoymouse(TRUE);
  247.                   }
  248.                   break;
  249.                case 5: /* Set JoyMouse Speed */
  250.                   SetJMSpeed();
  251.                   break;
  252.                case 6: /* Switch Sides */
  253.                   SimpleRequest("Unimplemented!");
  254.                   break;
  255.                case 7: /* Explain Invalid Move */
  256.                   ExplainError(last_error);
  257.                   break;
  258.                default:
  259.                    SimpleRequest("Unknown Item number (Menu 2) !");
  260.                    break;
  261.             }
  262.             break;
  263.          default:
  264.             SimpleRequest("Unknown Menu number !");
  265.             break;
  266.      }
  267.      MenuNumber = MyItem->NextSelect;
  268.   }
  269. }
  270.  
  271. void handle_mouseevents()
  272. {
  273.    static UBYTE ConfirmX, ConfirmY, HighX, HighY;
  274.    static int PNum,moveresult;
  275.    UBYTE X,Y;
  276.    int base,playernr,checkresult;
  277.    if (Coords(msg->MouseX,msg->MouseY,&X,&Y))
  278.    {
  279.       switch (status & (WAITING_FOR_PICK|WAITING_FOR_DEST|WAITING_FOR_CONF))
  280.       {
  281.          case WAITING_FOR_PICK:  /* dieser Mausklick müßte einen Spielstein
  282.                                     ausgewählt haben */
  283.             PNum = whatsonboard[X][Y];
  284.             base = (status & PLAYER1_TO_MOVE) ? 0 : 8;
  285.             if (PNum >= base && PNum < base +8)
  286.             {
  287.                Highlight(X,Y); /* gültige Wahl */
  288.                HighX=X; HighY=Y;
  289.                status &= (~WAITING_FOR_PICK);
  290.                status |= WAITING_FOR_DEST;
  291.                OffMenu(MyWindow,SHIFTMENU(0)|SHIFTITEM(NOITEM));
  292.                OffMenu(MyWindow,SHIFTMENU(1)|SHIFTITEM(NOITEM));
  293.                OffMenu(MyWindow,SHIFTMENU(2)|SHIFTITEM(NOITEM));
  294.             }
  295.             break;
  296.          case WAITING_FOR_DEST: /* dieser Mausklick müßte das Zielfeld
  297.                                     ausgewählt haben */
  298.             playernr = !(status & PLAYER1_TO_MOVE); /* Nummer des Spielers */
  299.             checkresult = check_move(whatsonboard,ThePieces,PNum,X,Y);
  300.             if (checkresult == MOVE_X_FIRST || checkresult == MOVE_Y_FIRST)
  301.             {
  302.                if (help[playernr]==SHOWKNOWN)
  303.                   Exchange(&fval[PNum][X][Y],&kval[PNum][X][Y]);
  304.                Highlight(HighX,HighY); /* Highlight löschen */
  305.                moveresult = do_move(whatsonboard,ThePieces,PNum,X,Y,
  306.                                     (checkresult==MOVE_X_FIRST));
  307.                if (help[playernr]>NOHELP)
  308.                {
  309.                   status &= (~WAITING_FOR_DEST);
  310.                   status |= WAITING_FOR_CONF;
  311.                   ConfirmX=X;
  312.                   ConfirmY=Y;
  313.                   if (status & PLAYER1_TO_MOVE)
  314.                      DrawText(10,JAM1,223,16,"Player 1");
  315.                   else
  316.                      DrawText(10,JAM1,223,49,"Player 2");
  317.                } else {
  318.                   kval[PNum][X][Y] = fval[PNum][X][Y];
  319.                   Notify(playernr,moveresult);
  320.                   if (status & IN_GAME)
  321.                   {
  322.                      if (status & PLAYER1_TO_MOVE)
  323.                      {
  324.                         status &= (~PLAYER1_TO_MOVE);
  325.                         NextPlayer(WHITE);
  326.                      } else {
  327.                         status |= PLAYER1_TO_MOVE;
  328.                         NextPlayer(RED);
  329.                      }
  330.                      status &= (~WAITING_FOR_DEST);
  331.                      status |= WAITING_FOR_PICK;
  332.                   }
  333.                   OnMenu(MyWindow,SHIFTMENU(0)|SHIFTITEM(NOITEM));
  334.                   OnMenu(MyWindow,SHIFTMENU(1)|SHIFTITEM(NOITEM));
  335.                   OnMenu(MyWindow,SHIFTMENU(2)|SHIFTITEM(NOITEM));
  336.                   OffMenu(MyWindow,SWITCHSIDENR);
  337.                }
  338.             } else if (checkresult & CANT_BEAT_BUDDY) /* anderer Stein */
  339.             {
  340.                Highlight(HighX,HighY);
  341.                HighX=X; HighY=Y;
  342.                PNum = whatsonboard[X][Y];
  343.                Highlight(HighX,HighY);
  344.             } else {    /* Zug ist ungültig */
  345.                last_error = checkresult;
  346.             }
  347.             break;
  348.          case WAITING_FOR_CONF:
  349.             status &= (~WAITING_FOR_CONF);
  350.             playernr = !(status & PLAYER1_TO_MOVE); /* Nummer des Spielers */
  351.             if (X==ConfirmX && Y==ConfirmY)
  352.             {
  353.                status |= WAITING_FOR_PICK;
  354.                if (help[playernr]==SHOWKNOWN)
  355.                {
  356.                   Exchange(&fval[PNum][X][Y],&kval[PNum][X][Y]);
  357.                   ThePieces[PNum].Value = fval[PNum][X][Y];
  358.                   SetPiece(ThePieces[PNum],FALSE,FALSE);
  359.                }
  360.                Notify(playernr,moveresult);
  361.                kval[PNum][X][Y] = fval[PNum][X][Y];
  362.                if (status & IN_GAME)
  363.                {
  364.                   if (status & PLAYER1_TO_MOVE)
  365.                   {
  366.                      status &= (~PLAYER1_TO_MOVE);
  367.                      NextPlayer(WHITE);
  368.                   } else {
  369.                      status |= PLAYER1_TO_MOVE;
  370.                      NextPlayer(RED);
  371.                   }
  372.                }
  373.                OnMenu(MyWindow,SHIFTMENU(0)|SHIFTITEM(NOITEM));
  374.                OnMenu(MyWindow,SHIFTMENU(1)|SHIFTITEM(NOITEM));
  375.                OnMenu(MyWindow,SHIFTMENU(2)|SHIFTITEM(NOITEM));
  376.                OffMenu(MyWindow,SWITCHSIDENR);
  377.             } else {
  378.                undo();
  379.                Highlight(HighX,HighY); /* alte Startposition */
  380.                status |= WAITING_FOR_DEST;
  381.                if (status & PLAYER1_TO_MOVE)
  382.                   DrawText(9,JAM1,223,16,"Player 1");
  383.                else
  384.                   DrawText(9,JAM1,223,49,"Player 2");
  385.                if (help[playernr]==SHOWKNOWN)
  386.                   Exchange(&fval[PNum][ConfirmX][ConfirmY],
  387.                            &kval[PNum][ConfirmX][ConfirmY]);
  388.                }
  389.             break;
  390.          default:
  391.             break;
  392.       }
  393.    }
  394. }
  395.  
  396. void main(void)
  397. {
  398.    open_all();
  399.    drawboard();
  400.    drawplayers(NULL,NULL);
  401.    setup_stdboard(FALSE);  /* Standard, nicht gedreht */
  402.    joymouse_allowed=TRUE;
  403.    ScreenToFront(MyScreen);
  404.    wait_events();
  405. }
  406.